home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #2 / Ham Radio 2000 - Volume 2.iso / HAMV2 / TCP_IP / HAGEMAN / PIC_CODE / ANALYZER.C next >
C/C++ Source or Header  |  1997-10-07  |  8KB  |  423 lines
  1. //==================================================================
  2. //=====                                   =====
  3. //=====        Network Analyzer PIC Interface Program          =====
  4. //=====            By: Steve Hageman 12Jan97                   =====
  5. //=====                                   =====     
  6. //==================================================================
  7. //=====  Version: 1.1 - Initial Release, 70% ROM Used  12Jan97 =====
  8. //=====           2.0 - Changed the return 'OK' to '*' 16Feb97 =====
  9. //=====                 to speed things up - 66% ROM Used      =====
  10. //=====           2.1 - I took the easy way out and swapped pin=====
  11. //=====                 B3,B4 to match the schematic, this     =====
  12. //=====                 does not match my prototype, but it    =====
  13. //=====                 does match the ARRL schematic. 4Oct97  =====
  14. //==================================================================
  15.  
  16. //-----< Initilization code >---------------------------------------
  17.  
  18. //----- Include Files -----
  19. #include <16c71.h>
  20. #include <stdio.h>
  21.  
  22. //----- Compiler use statements -----
  23. #use delay(clock=4000000)
  24. #use rs232(baud=9600, xmit=PIN_B7, rcv=PIN_A4, invert)
  25.  
  26. //----- RS232 pins -----
  27. #define RS232_OUT    PIN_B7
  28. #define RS232_IN    PIN_A4
  29.  
  30. //----- Port defines -----
  31. #define TRIS_A      0x85
  32. #define TRIS_B      0x86
  33. #define PORT_A_REG  0x05
  34. #define PORT_B_REG  0x06
  35. #define FSR         0x04
  36.  
  37. //----- Pin defines -----
  38. #pragma byte port_a = 0x05
  39. #pragma byte port_b = 0x06
  40.  
  41. //----- DDS Chip Pins (45102) -----
  42. #pragma bit SDATA = port_b.0
  43. #pragma bit SCLK = port_b.1
  44. #pragma bit XFER = port_b.2
  45.  
  46. //----- DDS Attenuator ------
  47. #pragma bit SOURCE_ATTEN_A = port_b.3
  48. #pragma bit SOURCE_ATTEN_B = port_b.4
  49.  
  50. //----- Receiver Attenuators -----
  51. #pragma bit REFLECTION_ATTEN   = port_b.5
  52. #pragma bit TRANSMISSION_ATTEN = port_b.6
  53.  
  54. //-----< General Defines >-----
  55. #define DOOMSDAY    0    // Not here yet!
  56.  
  57. //----- Analog A/D Channel Mapping -----
  58. #define REF_CHAN    0    
  59. #define THRU_CHAN    1
  60. #define PHASE_CHAN    2
  61.  
  62. //-----< Global Variables >-----
  63. char Buf;    // RS232 receive char
  64.  
  65. //-----< Subroutines >------------------------------------------------
  66. void set_dds_frequency(void)
  67. {
  68.     //----- Read RS232 and set frequency -----
  69.  
  70.     // Loop and shift each bit into the DDS chip
  71.     while(!DOOMSDAY)
  72.     {
  73.         // Inner loop as long as char != 'E'
  74.         Buf = getc(); 
  75.                                             
  76.         // If this char is a E that means end
  77.         switch(Buf)
  78.         {
  79.             case 'E':
  80.             {
  81.                 // XFER Data to DDS chip output register
  82.                 XFER = 0;
  83.                 XFER = 1;
  84.             
  85.                 // Write OK back to calling program
  86.                 puts("*");
  87.                 return;
  88.             }
  89.         
  90.             // Write a one bit to the DDS
  91.             case '1':
  92.             {
  93.                 SDATA = 1;
  94.                 SCLK = 1;
  95.                 SCLK = 0;
  96.                 SDATA = 0;
  97.                 PUTS("*");
  98.                 break;
  99.             }
  100.             
  101.             // Write a zero bit to the DDS
  102.             case '0':
  103.             {
  104.                 SDATA = 0;
  105.                 SCLK = 1;
  106.                 SCLK = 0;
  107.                 PUTS("*");
  108.                 break;
  109.             }
  110.             
  111.             // Error
  112.             default:
  113.             {
  114.                 puts("ERROR");
  115.                 return;
  116.             }
  117.  
  118.         } // End of switch
  119.  
  120.     } // End of while
  121. } 
  122.  
  123.  
  124. void set_dds_attenuator()
  125. {
  126.     // Read setting from RS232
  127.     Buf = getc(); 
  128.         
  129.     // Set DDS Attenuator
  130.     switch(Buf) {
  131.  
  132.         case '1': {
  133.             // 5 dBv Max power
  134.             SOURCE_ATTEN_A = 1;
  135.             SOURCE_ATTEN_B = 1;
  136.             break;
  137.         }        
  138.         case '2': {
  139.             // 0 dBv
  140.             SOURCE_ATTEN_A = 0;
  141.             SOURCE_ATTEN_B = 0;
  142.             break;
  143.         }
  144.         case '3': {
  145.             // -20 dBv
  146.             SOURCE_ATTEN_A = 1;
  147.             SOURCE_ATTEN_B = 0;
  148.             break;
  149.         }
  150.         case '4': {
  151.             // -40 dBv
  152.             SOURCE_ATTEN_A = 0;
  153.             SOURCE_ATTEN_B = 1;
  154.             break;
  155.         }
  156.         default: {
  157.             // Error
  158.             puts("ERROR");
  159.             return;        
  160.         }
  161.     
  162.     }
  163.     // Send OK back
  164.     puts("*");
  165. }
  166.  
  167.  
  168. read_send_channel(int chan)
  169. {
  170. int value;
  171.  
  172.     // Set the A/D Channel, Wait for settling delay
  173.     set_adc_channel(chan);
  174.     delay_us(10);
  175.     
  176.     // Read the specified A/D channel
  177.     value = read_adc();
  178.     
  179.     // Send result back on RS232 as decimal, ASCII value
  180.     putc( (value/100) + '0' );
  181.     putc( ((value/10) % 10) + '0');
  182.     putc( (value%10) + '0');
  183. }
  184.  
  185.  
  186. set_attenuator(int chan)
  187. {
  188.     // Read setting from RS232
  189.     Buf = getc();
  190.     
  191.     // Set attenuator as needed
  192.     switch(Buf) 
  193.     {
  194.         case '1':
  195.         {
  196.             // NOTE: A one means close relay
  197.             // setting attenuator OFF
  198.             if(chan == REF_CHAN)
  199.             {
  200.                 REFLECTION_ATTEN = 0;
  201.             }
  202.             else
  203.             {
  204.                 TRANSMISSION_ATTEN = 0;
  205.             }
  206.             break;
  207.         }
  208.     
  209.         case '0':
  210.         {
  211.             // Set attenuator OFF
  212.             if(chan ==  REF_CHAN)
  213.             {
  214.                 REFLECTION_ATTEN = 1;
  215.             }
  216.             else
  217.             {
  218.                 TRANSMISSION_ATTEN = 1;
  219.             }
  220.             break;
  221.         }    
  222.         
  223.         default: {
  224.             // Error
  225.             puts("ERROR");
  226.             return;        
  227.         }    
  228.     
  229.     } // End of switch
  230.     
  231.     // Send OK back
  232.     puts("*");
  233. }
  234.  
  235.  
  236. //-----< Main >----------
  237. void main(void)
  238. {
  239.  
  240.     // Setup Ports
  241.     #asm
  242.         clrf PORT_B_REG     // Clear port b
  243.         
  244.         movlw TRIS_B        // Setup port B TRIS reg
  245.         movwf FSR
  246.         
  247.         // Set 0-7 bits all output 
  248.         bcf 00,0    // SData        
  249.         bcf 00,1    // SClock
  250.         bcf 00,2    // XFER#
  251.         bcf 00,3    // DDS Range Pin A
  252.         bcf 00,4    // DDS Range Pin B
  253.         bcf 00,5    // Ref Range Relay
  254.         bcf 00,6    // Thru Range Relay
  255.         bcf 00,7    // RS232 Output
  256.     #endasm
  257.     
  258.     // Setup A/D
  259.     setup_port_a(ALL_ANALOG);
  260.     setup_adc(ADC_CLOCK_DIV_8);    // OK for 4 MHz Clock
  261.     
  262.     // Set output source attenuator to 0 dBm
  263.     SOURCE_ATTEN_A = 1;
  264.     SOURCE_ATTEN_B = 0;
  265.  
  266.     // Set receiver attenuators ON
  267.     REFLECTION_ATTEN   = 0;
  268.     TRANSMISSION_ATTEN = 0;
  269.     
  270.     // Set initial program start DDS State
  271.     SCLK = 0;
  272.     SDATA = 0;
  273.     XFER = 1;
  274.     
  275.     // Initilize RS232 pin, send a 0. 
  276.     // This sets up the RS232 properly
  277.     putc(' ');
  278.     
  279.     // Main loop
  280.     while(!DOOMSDAY)
  281.     {
  282.         // Wait for RS232 char -> parse to command
  283.         Buf = getc();
  284.         
  285.         switch(Buf)
  286.         {
  287.         
  288.             // DDS Source Parser
  289.               case 'S': {
  290.                   
  291.                   puts("*");
  292.                   
  293.                   // Get next char
  294.                   Buf = getc();
  295.                   
  296.                   switch(Buf) {
  297.                   
  298.                       case 'F':
  299.                       {    
  300.                           puts("*");
  301.                           // Set frequency command
  302.                           set_dds_frequency();
  303.                           break;
  304.                       }                              
  305.                   
  306.                       case 'A':    
  307.                       {
  308.                           puts("*");        
  309.                           // Set attenuator command
  310.                           set_dds_attenuator();
  311.                           break;
  312.                       }
  313.                       
  314.                       default:
  315.                       {
  316.                           puts("ERROR");
  317.                       }    
  318.                   } 
  319.                   break;
  320.               }
  321.               
  322.               // Ref Chan Parser
  323.               case 'R': {
  324.                   
  325.                   puts("*");
  326.                   
  327.                   // Get next char
  328.                   Buf = getc();
  329.               
  330.                   switch(Buf) {
  331.                   
  332.                       case '?':
  333.                       {    
  334.                           puts("*");
  335.                           // Read channel command
  336.                           read_send_channel(REF_CHAN);
  337.                           break;
  338.                       }                              
  339.                       case 'A':    
  340.                       {
  341.                           puts("*");
  342.                           // Set attenuator command
  343.                           set_attenuator(REF_CHAN);
  344.                           break;
  345.                       }
  346.                       default:
  347.                       {
  348.                           puts("ERROR");
  349.                       }
  350.                   }
  351.                   break;
  352.               }
  353.             
  354.             // Thru Chan Parser
  355.               case 'T': {
  356.               
  357.                   puts("*");
  358.                   
  359.                   // Get next char
  360.                   Buf = getc();
  361.               
  362.                   switch(Buf) {
  363.                   
  364.                       case '?':
  365.                       {    
  366.                           puts("*");
  367.                           // Read channel command
  368.                           read_send_channel(THRU_CHAN);
  369.                           break;
  370.                       }                              
  371.                       case 'A':    
  372.                       {
  373.                           puts("*");
  374.                           // Set attenuator command
  375.                           set_attenuator(THRU_CHAN);
  376.                           break;
  377.                       }
  378.                       default:
  379.                       {
  380.                           puts("ERROR");
  381.                       }
  382.                   }
  383.               break;
  384.               }
  385.               
  386.             // Phase Chan Parser
  387.               case 'P': {
  388.               
  389.                   puts("*");
  390.                   
  391.                   // Get next char
  392.                   Buf = getc();
  393.                 
  394.                 switch(Buf) {
  395.                           
  396.                       case '?':
  397.                       {    
  398.                           puts("*");
  399.                           // Read channel command
  400.                           read_send_channel(PHASE_CHAN);
  401.                           break;
  402.                       }
  403.                       
  404.                       default:
  405.                       {
  406.                           puts("ERROR");
  407.                       }
  408.                   }
  409.               break;                                  
  410.             }              
  411.             
  412.             // Not in command list
  413.             default: {
  414.                 // Error
  415.                 puts("ERROR");
  416.             }
  417.         
  418.         } // End of switch
  419.  
  420.     } // End of while
  421.  
  422. } //----- End of main -----
  423.